//箭头函数

// function func(number){
//     return number + 1
// }

// const func = (n,m) => n + m
// console.log(func.constructor)
//构造函数模式
// function Cat(name,color){
//     this.name = name
//     this.color = color
// }
// let cat1 = new Cat("大毛","灰色")

// let cat2 = new Cat("二毛","白色")
// //cat1，cat2 会含有一个constructor属性，指向他们的构造函数
// console.log(cat1.constructor === Cat)//true
// console.log(cat2.constructor === Cat)//true
// console.log(Cat.prototype.constructor === Cat)
// //instanceof运算符 实例对象对象与验证原型之间的关系
// console.log(cat1 instanceof Cat)//true
// console.log(cat2 instanceof Cat)//true



//构造函数模式的问题 
// function Cat(name,color){
//     this.name = name
//     this.color = color
//     this.type = "猫科动物"
//     this.eat = function(){
//         console.log("吃老鼠")
//     }
// }
// let cat1 = new Cat("大毛","灰色")
// let cat2 = new Cat("二毛","白色")
// cat1.eat()//吃老鼠
//每一个实例对象 type属性和eat方法都是一模一样的，每次生成一个实例，都生成一个重复的内容，多占用内存
// console.log(cat1.eat === cat2.eat)//false
//我们可以让type属性和eat方法在内存中只生成一次，然后所有实例都指向同一个内存地址。
//----------------------------------------------------------
//prototype模式
//每一个构造函数都有一个prototype属性，指向另一个对象，这个对象的所有属性和方法，都被构造函数的实例继承
//把不变的属性和方法都定义在prototype上
// function Cat(name,color){
//     this.name = name
//     this.color = color
// }
// Cat.prototype.type = "猫科动物"
// Cat.prototype.eat = function(){
//     console.log("吃老鼠")
// }
// let cat1 = new Cat("大毛","灰色")
// let cat2 = new Cat("二毛","白色")
// cat1.eat()//吃老鼠
//实例的type属性和eat方法都是一个内存地址,指向同一个prototype对象
// console.log(cat1.eat === cat2.eat)//true

//构造函数继承

// function Animal(){
//     this.species = "动物"
// }

// function Cat(name,color){
//     Animal.call(this,arguments)
//     this.name = name
//     this.color = color
//  }
//  let cat1 = new Cat("大毛","紫色")
//  console.log(cat1.species)
 //每个构造函数都有一个prototyoe属性，prototype指向一个对象，这个对象的所有属性和方法都会被构造函数的实例继承
 // isPrototypeOf() 判断prototype对象和某个实例之间的关系
//  console.log(Cat.prototype.isPrototypeOf(cat1))
 //hasOwnProperty
//每一个实例对象都有一个hasOwnProperty()方法，用来判断到底是本地属性，还是继承自prototype对象的属性
// console.log(cat1.hasOwnProperty("name"))//true
// console.log(cat1.hasOwnProperty("false"))//false
//in运算符
// setTimeout最终会被放在全局对象上调用
// var name = "ykk"
// const person = {
//     name:"tom",
//     say:()=>{
//         setTimeout(()=>{
//             console.log(this.name)
//         },1000)
       
//     }
// }
// person.say()

//每一个实例都有一个constructor属性， 指向他的构造函数 ，默认指向prototype对象的constructor属性
//任何一个prototype对象都有一个constructor属性，指向他的构造函数

// function Cat(name,color){
//    this.name = name
//    this.color = color
   //每一个实例对象，type属性和eat方法的内容都是一模一样的，每车次生成一个实例，都是重复的内容，占用内存。我们可以把不变的属性和方法放在prototype
//    this.type = "动物"
//    this.eat = function(){
//        console.log("吃老鼠")
//    }
// }
//js规定，任何一个构造函数都有一个prototype属性，指向另一个对象，这个对象的属性和方法被构造函数的实例继承
// Cat.prototype.type="动物"
// Cat.prototype.eat = function(){
//     console.log("吃老鼠")
// }
// let cat1 = new Cat("大毛","紫色")
// let cat2 = new Cat("二毛","红色")
//每一个实例都有一个constructor属性， 指向他的构造函数 ，默认指向prototype对象的constructor属性
// console.log(cat1.constructor === Cat)
//任何一个prototype对象都有一个constructor属性，指向他的构造函数
// console.log(Cat.prototype.constructor === Cat)
//验证对象与实例之间的关系
// console.log(cat1 instanceof Cat)
//继承1
function Animal(){
    this.species = "动物";
}
function Cat(name,color){
    this.name = name
    this.color = color
}
//将Cat.prototype对象指向new Animal()实例
Cat.prototype = new Animal()
//每一个prototype对象都有一个constructor属性，执行他的构造函数，如果Cat.prototype = new Animal()，Cat.prototype.constructor是等于Cat的
//加上Cat.prototype = new Animal()，Cat.prototype.constructor属性是指向Animal
Cat.prototype.constructor = Cat
let cat1 = new Cat()
// console.log(cat1.species)
//每一个实例也有一个constructor属性，默认调用prototype对象的constructor属性，因此当Cat.prototype = new Animal()的时候，cat1.constructor是指向Animal的，所以我们需要纠正Cat.prototype.constructor = Cat
// console.log(Cat.prototype.constructor === cat1.constructor)//true
let o = {}
o.prototype = {}
console.log(o.prototype.constructor)
Object.assign()


